package com.hspedu.innerclass;


/**
 * 演示匿名类的使用
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.method();
    }
}

class Outer02 {//外部类
    private int n1 = 10;//属性

    public void method() {
        //基于接口的匿名内部类
        //老韩解读
        //1.需求：想使用IA接口，并创建对象
        //2.传统方式，写一个类实现接口，并创建对象
        //3.需求：Tiger这个对象只使用一次，后再不使用了
        //4.可以使用匿名内部类来简化开发
        //5.tiger的编译类型 是A 接口,
        //         运行类型就是匿名内部类 XXXX = Outer02$1
        /*
            我们看底层，系统会分配类型 类名$1 用一次就没有了
            class XXXX implement IA{
                 @Override
                 public void cry() {
                    System.out.println("老虎叫唤..");
                 }
            }
         */
        //7.jdk底层在创建匿名内部类 Outer02$1,立马创建Outer02$1实例，并把地址返回给tiger
        //8.匿名内部类使用一次，就不再使用了，在内存中找不到了
        A tiger = new A() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤..");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        //tiger的运行类型=class com.hspedu.innerclass.Outer02$1

        tiger.cry();
        tiger.cry();
        tiger.cry();
        //A tiger = new Tiger();
        //tiger.cry();


        //基于类的匿名内部类
        //分析
        //1.father编译类型 Father
        //2.father运行类型 Outer01$2
        //3.底层
        /*
            class Outer02$2 extend Father{
               public void test() {
                    System.out.println("匿名内部类重写了test方法..");
               }
            }
         */

        //4. 同时也直接返回了 匿名内部类 Outer02$2的对象
        //5. 注意：("jack") 会传递给Father构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法..");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());
        //father对象的运行类型=class com.hspedu.innerclass.Outer02$2
        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("小狗吃东西..");
            }
        };
        System.out.println("animal的运行类型=" + animal.getClass());
        animal.eat();

    }
}

interface A {//接口

    public void cry();
}

/*class Tiger implements A {
    @Override
    public void cry() {
        System.out.println("老虎叫唤..");
    }
}

class Dog implements A{

    @Override
    public void cry() {
        System.out.println("小狗叫唤..");
    }
}*/

class Father {//类
    String name;
    public Father(String name) {//构造器
        System.out.println("接收到name：" + name);
        this.name = name;
    }

    public void test() {

    }
}

class B extends Father{

    public B(String name) {
        super(name);
    }
}

abstract class Animal{
    abstract void eat();
}